home *** CD-ROM | disk | FTP | other *** search
/ Joystick Magazine 1996 May / cd joy 71No13.iso / pc / demos / eurosoc / source / video.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-06  |  7.9 KB  |  396 lines
  1. #include <iostream.h>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <graph.h>
  5. #include <i86.h>
  6. #include <dos.h>
  7. #include <conio.h>
  8. #include <float.h>
  9. #include <time.h>
  10. #include <math.h>
  11. #include <string.h>
  12.  
  13. #include "defines.h"
  14. #include "3deng.h"
  15. #include "video.h"
  16. #include "gamedata.h"
  17.  
  18. int    gdv_gran;
  19. extern    int    winrange,Vbytesperline;
  20.  
  21. #ifndef min
  22. #define min(a,b)  (((a) < (b)) ? (a) : (b))
  23. #endif
  24.  
  25. #ifndef abs
  26. #define abs(a)        (((a) < 0) ? -(a) : (a))
  27. #endif
  28.  
  29. struct RMI
  30. {
  31.     long            EDI;
  32.     long            ESI;
  33.     long            EBP;
  34.     long            reserved;
  35.     long            EBX;
  36.     long            EDX;
  37.     long            ECX;
  38.     long            EAX;
  39.     short            flags;
  40.     short            ES, DS, FS, GS, IP, CS, SP, SS;
  41. };
  42.  
  43. struct
  44. {
  45.     unsigned short                    attributes;
  46.     unsigned char                    win_a_attr;
  47.     unsigned char                    win_b_attr;
  48.     unsigned short                    win_granularity;
  49.     unsigned short                    win_size;
  50.     unsigned short                    win_a_segment;
  51.     unsigned short                    win_b_segment;
  52.     unsigned long                    win_windor;
  53.     unsigned short                    bytes_per_scanline;
  54.  
  55.     unsigned short                    x_resolution;
  56.     unsigned short                    y_resolution;
  57.     unsigned char                    x_char_size;
  58.     unsigned char                    y_char_size;
  59.     unsigned char                    mem_planes;
  60.     unsigned char                    bits_per_pixel;
  61.     unsigned char                    number_banks;
  62.     unsigned char                    mem_model;
  63.     unsigned char                    bank_size;
  64.     unsigned char                    number_images;
  65.     unsigned char                    reserved0;
  66.  
  67.     unsigned char                    red_mask_size;
  68.     unsigned char                    red_field_pos;
  69.     unsigned char                    green_mask_size;
  70.     unsigned char                    green_field_pos;
  71.     unsigned char                    blue_mask_size;
  72.     unsigned char                    blue_field_pos;
  73.     unsigned char                    rsvd_mask_size;
  74.     unsigned char                    reserved1[216];
  75. } ModeInfo;
  76.  
  77. int win_range;
  78.  
  79. void blank_pallette()
  80. {
  81.     outp( 0x3c8, 0 );
  82.  
  83.     for ( short loop = 0 ; loop < 768 ; loop++ )
  84.         outp( 0x3c9, 0 );
  85. }
  86.  
  87.  
  88.  
  89. void set_pallette( unsigned char *pallette )
  90. {
  91.     outp( 0x3c8, 0 );
  92.  
  93.     for ( short loop = 0 ; loop < 768 ; loop++ )
  94.         outp( 0x3c9, pallette[loop] >> 3);
  95. }
  96.  
  97.  
  98.  
  99. void set_pallette_entry( unsigned char color, unsigned char red, unsigned
  100.     char blue, unsigned char green )
  101. {
  102.     outp( 0x3c8, color );
  103.     outp( 0x3c9, red );
  104.     outp( 0x3c9, green );
  105.     outp( 0x3c9, blue );
  106. }
  107. //int set_vesa_mode( unsigned short mode_no, int checks )
  108. //{
  109. //
  110. //    if     ( match_info.menu_res==HI )
  111. //    {
  112. //            
  113. //        REGS            regs;
  114. //        SREGS            sregs;
  115. //         short            segment, off, result, selector;
  116. //        char            far *ptr;
  117. //        RMI            real_mode;
  118. //
  119. //        if (checks)
  120. //        {
  121. //            //    Create a temporary working space for real mode interrupts...
  122. //            memset( &sregs, 0, sizeof( SREGS ) );
  123. //
  124. //            // Call the DPMI function to allocate 256 bytes of DOS memory
  125. //            regs.w.ax = 0x0100;
  126. //            regs.w.bx = (sizeof(ModeInfo) / 16) + 1;
  127. //            int386x( 0x31, ®s, ®s, &sregs );
  128. //
  129. //            segment = regs.w.ax;
  130. //            selector = regs.w.dx;
  131. //
  132. //            // Make use a far pointer to the base memory so we can reference it
  133. //            ptr = (char far *) MK_FP( selector, 0 );
  134. //
  135. //            memset( &real_mode, 0, sizeof( RMI ) );
  136. //            real_mode.EAX = 0x4f01;
  137. //            real_mode.ECX = mode_no;
  138. //            real_mode.EDI = 0;
  139. //            real_mode.ES = segment;
  140. //
  141. //            regs.w.ax = 0x0300;
  142. //            regs.h.bl = 0x10;
  143. //            regs.h.bh = 0;
  144. //            regs.w.cx = 0;
  145. //            sregs.es = FP_SEG( &real_mode );
  146. //            regs.x.edi = FP_OFF( &real_mode );
  147. //
  148. //            int386x( 0x31, ®s, ®s, &sregs );
  149. //
  150. //            _fmemcpy( &ModeInfo, ptr, sizeof( ModeInfo ) );
  151. //
  152. //            // Free the 256 byte base memory
  153. //            regs.w.ax = 0x101;
  154. //            regs.w.dx = selector;
  155. //            int386( 0x31, ®s, ®s );
  156. //
  157. //            result = (short) real_mode.EAX;
  158. //
  159. //            if (result != 0x004f)
  160. //                return VESA_MODE_NOT_SUPPORTED;
  161. //
  162. //        // Mode was ok to get info, so lets continue to actually set the mode...
  163. //    }
  164. //
  165. //        regs.w.ax = 0x4f02;
  166. //        regs.w.bx = mode_no;
  167. //        int386( 0x10, ®s, ®s );
  168. //
  169. //    // last ditch effort
  170. //
  171. //        if (regs.h.ah != 0)
  172. //        {
  173. //            regs.h.ah = 0;
  174. //            regs.h.al = (char) mode_no;
  175. //            int386( 0x10, ®s, ®s );
  176. //        }
  177. //
  178. //    //    Make sure the Window A pointer is set to 0
  179. //
  180. //        if (checks)
  181. //        {
  182. //            regs.w.ax = 0x4f05;
  183. //            regs.w.bx = 0x0000;
  184. //            regs.w.dx = 0x0000;
  185. //            int386( 0x10, ®s, ®s );
  186. //        }
  187. //
  188. //        win_range = (ModeInfo.win_granularity * 1024 );
  189. //    }
  190. //    return VESA_MODE_OK;
  191. //}
  192.  
  193.  
  194.  
  195.  
  196.  
  197. void svgacopy(unsigned char *buffpt,short x,short y,short w,short h, short buff_wid)
  198. {
  199.     win_range    =    winrange;
  200.     ModeInfo.bytes_per_scanline    =    Vbytesperline;
  201.  
  202.     if     ( match_info.menu_res==HI )
  203.     {
  204.  
  205.         union REGS regs;
  206.  
  207.         short i,co;
  208.         char *scrpt;
  209.         int scrdisp=x +ModeInfo.bytes_per_scanline * y;
  210.         char bank=scrdisp / win_range;
  211.  
  212.         scrdisp%=win_range;
  213.         scrpt=(char *)0xa0000+scrdisp;
  214.         regs.x.eax=0x4f05;
  215.         regs.x.ebx=0;
  216.         regs.x.edx=bank;
  217.         int386(16,®s,®s);
  218.         do
  219.         {
  220.             co=min((win_range-scrdisp)/ModeInfo.bytes_per_scanline,h);
  221.             for (i=0;i<co;i++)
  222.             {
  223.                 memcpy(scrpt,buffpt,w);
  224.                 scrpt+=ModeInfo.bytes_per_scanline;
  225.                 buffpt+= buff_wid;
  226.                 h--;
  227.             }
  228.             if (h)
  229.             {
  230.                 scrdisp=(scrdisp+(co+1)*ModeInfo.bytes_per_scanline)%win_range;
  231.                 co=min(ModeInfo.bytes_per_scanline-scrdisp,w);
  232.                 memcpy(scrpt,buffpt,co);
  233.                  bank++;     
  234.                  regs.x.eax=0x4f05;
  235.                  regs.x.ebx=0;
  236.                  regs.x.edx=bank;
  237.                   int386(16,®s,®s);
  238.                  if (co!=w) 
  239.                     memcpy((char *)0xa0000,buffpt+co,w-co);
  240.                 scrpt=(char *)0xa0000+scrdisp;
  241.                 buffpt+=buff_wid;
  242.                 h--;
  243.              }
  244.         } while (h);
  245.     
  246.         regs.x.eax=0x4f05;
  247.         regs.x.ebx=0;
  248.         regs.x.edx=0;
  249.         int386(16,®s,®s);
  250.     }
  251.  
  252. //    else
  253. //    
  254. //    {
  255. //        SVGAxpos    =    x;
  256. //        SVGAypos    =    y;
  257. //        SVGAwidth    =    w;
  258. //        SVGAheight    =    h;
  259. //         svgacopy_LO();
  260. //    }    
  261. }
  262.  
  263. void svgaread(char *buffpt,short x,short y,short w,short h, short buff_wid)
  264. {
  265.     union REGS regs;
  266.     short i,co;
  267.     char *scrpt;
  268.     int scrdisp=x + ModeInfo.bytes_per_scanline * y;
  269.     char bank=scrdisp / win_range;
  270.  
  271.     scrdisp%=win_range;
  272.     scrpt=(char *)0xa0000+scrdisp;
  273.     regs.x.eax=0x4f05;
  274.     regs.x.ebx=1;
  275.     regs.x.edx=bank;
  276.     int386(16,®s,®s);
  277.     do
  278.     {
  279.         co=min((win_range-scrdisp)/ModeInfo.bytes_per_scanline,h);
  280.         for (i=0;i<co;i++)
  281.         {
  282.             memcpy(buffpt,scrpt,w);
  283.             scrpt+=ModeInfo.bytes_per_scanline;
  284.             buffpt+= buff_wid;
  285.             h--;
  286.         }
  287.         if (h)
  288.         {
  289.             scrdisp=(scrdisp+(co+1)*ModeInfo.bytes_per_scanline)%win_range;
  290.             co=min(ModeInfo.bytes_per_scanline-scrdisp,w);
  291.             memcpy(buffpt,scrpt,co);
  292.              bank++;     
  293.              regs.x.eax=0x4f05;
  294.              regs.x.ebx=1;
  295.              regs.x.edx=bank;
  296.               int386(16,®s,®s);
  297.              if (co!=w) 
  298.                 memcpy(buffpt+co,(char *)0xa0000,w-co);
  299.             scrpt=(char *)0xa0000+scrdisp;
  300.             buffpt+=buff_wid;
  301.             h--;
  302.          }
  303.     } while (h);
  304.  
  305.     regs.x.eax=0x4f05;
  306.     regs.x.ebx=1;
  307.     regs.x.edx=0;
  308.     int386(16,®s,®s);
  309. }
  310.  
  311. short get_curr_vmode()
  312. {
  313.     REGS                regs;
  314.  
  315.     regs.x.eax = 0x4f03;
  316.     int386( 0x10, ®s, ®s );
  317.  
  318.     if (regs.w.ax == 0x004f)
  319.         return regs.w.bx;
  320.     
  321.     return 0;
  322. }
  323.  
  324. void draw_line(    short x1, short y1,
  325.                         short x2, short y2, 
  326.                         char col, buff_info *buffer )
  327. {
  328.     int        x, y, deltax, deltay, i, numpixels;
  329.     int        d, dinc1, dinc2, xinc1, xinc2, yinc1, yinc2;
  330.  
  331.     deltax = abs(x2 - x1);
  332.     deltay = abs(y2 - y1);
  333.  
  334.     if (deltax >= deltay)
  335.     {
  336.         numpixels = deltax + 1;
  337.         d = (deltay << 1) - deltax;
  338.         dinc1 = deltay << 1;
  339.         dinc2 = (deltay - deltax) << 1;
  340.         xinc1 = 1;
  341.         xinc2    = 1;
  342.         yinc1 = 0;
  343.         yinc2 = 1;
  344.     }
  345.     else
  346.     {
  347.         numpixels = deltay + 1;
  348.         d = (deltax << 1) - deltay;
  349.         dinc1 = deltax << 1;
  350.         dinc2 = (deltax - deltay) << 1;
  351.         xinc1 = 0;
  352.         xinc2 = 1;
  353.         yinc1 = 1;
  354.         yinc2 = 1;
  355.     }
  356.  
  357.     if (x1 > x2)
  358.     {
  359.         xinc1 = -xinc1;
  360.         xinc2 = -xinc2;
  361.     }
  362.  
  363.     if (y1 > y2)
  364.     {
  365.         yinc1 = -yinc1;
  366.         yinc2 = -yinc2;
  367.     }
  368.  
  369.     x = x1;
  370.     y = y1;
  371.  
  372.     for ( i = 0; i < numpixels; i++ )
  373.     {
  374.         if ((x >= 0) && (x < buffer->clip_wid) && 
  375.              (y >= 0) && (y < buffer->clip_hgt))
  376.         {
  377.             *(buffer->buff_start + (y * buffer->buff_wid) + x) = col;
  378.         }
  379.  
  380.         if ( d < 0 )
  381.         {
  382.             d += dinc1;
  383.             x += xinc1;
  384.             y += yinc1;
  385.         }
  386.         else
  387.         {
  388.             d += dinc2;
  389.             x += xinc2;
  390.             y += yinc2;
  391.         }
  392.     }
  393. }
  394.  
  395.  
  396.